home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevpsim.c < prev    next >
C/C++ Source or Header  |  1996-08-16  |  8KB  |  247 lines
  1. /* Copyright (C) 1994, 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevpsim.c */
  20. /* PostScript image output device */
  21. #include "gdevprn.h"
  22.  
  23. /*
  24.  * This driver does what the ps2image utility used to do:
  25.  * It produces a bitmap in the form of a PostScript file that can be
  26.  * fed to any PostScript printer.  It uses a run-length compression
  27.  * method that executes quickly (unlike some produced by PostScript
  28.  * drivers!).
  29.  *
  30.  * There are two drivers here, one for 1-bit black-and-white and one
  31.  * for 8-bit gray.  In fact, the same code could also handles 2- and
  32.  * 4-bit gray output.
  33.  */
  34.  
  35. /* Define the device parameters. */
  36. #ifndef X_DPI
  37. #  define X_DPI 300
  38. #endif
  39. #ifndef Y_DPI
  40. #  define Y_DPI 300
  41. #endif
  42.  
  43. /* The device descriptor */
  44. private dev_proc_print_page(psmono_print_page);
  45.  
  46. gx_device_printer far_data gs_psmono_device =
  47.   prn_device(prn_std_procs, "psmono",
  48.     DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  49.     X_DPI, Y_DPI,
  50.     0, 0, 0, 0,        /* margins */
  51.     1, psmono_print_page);
  52.  
  53. private const gx_device_procs psgray_procs =
  54.   prn_color_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
  55.     gx_default_gray_map_rgb_color, gx_default_gray_map_color_rgb);
  56.  
  57. gx_device_printer far_data gs_psgray_device = {
  58.   prn_device_body(gx_device_printer, psgray_procs, "psgray",
  59.     DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  60.     X_DPI, Y_DPI,
  61.     0, 0, 0, 0,        /* margins */
  62.     1, 8, 255, 0, 256, 1, psmono_print_page)
  63. };
  64.  
  65. /*
  66.  * The following setup code gets written to the PostScript file.
  67.  * We would have to break it up anyway because the Watcom compiler has
  68.  * a limit of 512 characters in a single token, so we make a virtue out of
  69.  * necessity and make each line a separate string.
  70.  */
  71. private const char far_data *psmono_setup[] = {
  72. "%!PS",
  73. "  /maxrep 255 def        % max repeat count",
  74. "        % Initialize the strings for filling runs (lazily).",
  75. "     /.ImageFill",
  76. "      { maxrep string dup 0 1 maxrep 1 sub { 3 index put dup } for",
  77. "    .ImageFills 4 2 roll put",
  78. "      } bind def",
  79. "     /.ImageFills [ 0 1 255 {",
  80. "    /.ImageFill cvx 2 array astore cvx",
  81. "     } for ] def",
  82. "        % Initialize the procedure table for input dispatching.",
  83. "     /.ImageProcs [",
  84. "        % Stack: <buffer> <file> <xdigits> <previous> <byte>",
  85. "     32 { { pop .ImageItem } } repeat",
  86. "     16 { {    % 0x20-0x2f: (N-0x20) data bytes follow",
  87. "      32 sub 3 -1 roll add 3 index exch 0 exch getinterval 2 index exch",
  88. "      readhexstring pop exch pop 0 exch dup",
  89. "     } bind } repeat",
  90. "     16 { {    % 0x30-0x3f: prefix hex digit (N-0x30) to next count",
  91. "      48 sub 3 -1 roll add 4 bitshift exch .ImageItem",
  92. "     } bind } repeat",
  93. "     32 { {    % 0x40-0x5f: repeat last data byte (N-0x40) times",
  94. "      64 sub 3 -1 roll add .ImageFills 2 index dup length 1 sub get get exec",
  95. "      exch 0 exch getinterval 0 3 1 roll",
  96. "     } bind } repeat",
  97. "     160 { { pop .ImageItem } } repeat",
  98. "     ] readonly def",
  99. "        % Read one item from a compressed image.",
  100. "        % Stack contents: <buffer> <file> <xdigits> <previous>",
  101. "  /.ImageItem",
  102. "   { 2 index read pop dup .ImageProcs exch get exec",
  103. "   } bind def",
  104. "        % Read and print an entire compressed image.",
  105. "  /.ImageRead        % <xres> <yres> <width> <height> <bpc> .ImageRead -",
  106. "   { gsave [",
  107.     /* Stack: xres yres width height bpc -mark- */
  108. "     6 -2 roll exch 72 div 0 0 4 -1 roll -72 div 0 7 index",
  109.     /* Stack: width height bpc -mark- xres/72 0 0 -yres/72 0 height */
  110. "     ] { .ImageItem }",
  111.     /* Stack: width height bpc <matrix> <proc> */
  112. "     4 index 3 index mul 7 add 8 idiv string currentfile 0 ()",
  113.     /* Stack: width height bpc <matrix> <proc> <buffer> <file> 0 () */
  114. "     9 4 roll",
  115.     /* Stack: <buffer> <file> 0 () width height bpc <matrix> <proc> */
  116. "     image pop pop pop pop",
  117. "     grestore showpage",
  118. "   } def"
  119. };
  120.  
  121. #define data_run_code 0x20
  122. #define xdigit_code 0x30
  123. #define max_data_per_line 35
  124. #define repeat_run_code 0x40
  125. #define max_repeat_run_code 31
  126. #define max_repeat_run 255
  127.  
  128. /* Send the page to the printer. */
  129. private void write_data_run(P4(const byte *, int, FILE *, byte));
  130. private int
  131. psmono_print_page(gx_device_printer *pdev, FILE *prn_stream)
  132. {    int line_size = gdev_mem_bytes_per_scan_line((gx_device *)pdev);
  133.     int lnum;
  134.     byte *line = (byte *)gs_malloc(line_size, 1, "psmono_print_page");
  135.     byte invert = (pdev->color_info.depth == 1 ? 0xff : 0);
  136.  
  137.     if ( line == 0 )
  138.       return_error(gs_error_VMerror);
  139.  
  140.     /* If this is the first page of the file, */
  141.     /* write the setup code. */
  142.     if ( gdev_prn_file_is_new(pdev) )
  143.       {    int i;
  144.         for ( i = 0; i < countof(psmono_setup); i++ )
  145.           fprintf(prn_stream, "%s\r\n", psmono_setup[i]);
  146.       }
  147.  
  148.     /* Write the .ImageRead command. */
  149.     fprintf(prn_stream,
  150.         "%g %g %d %d %d .ImageRead\r\n",
  151.         pdev->HWResolution[0], pdev->HWResolution[1],
  152.         pdev->width, pdev->height, pdev->color_info.depth);
  153.  
  154.     /* Compress each scan line in turn. */
  155.     for ( lnum = 0; lnum < pdev->height; lnum++ )
  156.       {    const byte *p;
  157.         int left = line_size;
  158.         byte *data;
  159.         gdev_prn_get_bits(pdev, lnum, line, &data);
  160.         p = data;
  161.         /* Loop invariant: p + left = data + line_size. */
  162. #define min_repeat_run 10
  163.         while ( left >= min_repeat_run )
  164.           {    /* Detect a maximal run of non-repeated data. */
  165.             const byte *p1 = p;
  166.             int left1 = left;
  167.             byte b;
  168.             int count, count_left;
  169.  
  170.             while ( left1 >= min_repeat_run &&
  171.                     ((b = *p1) != p1[1] ||
  172.                  b != p1[2] || b != p1[3] || b != p1[4] ||
  173.                  b != p1[5] || b != p1[6] || b != p1[7] ||
  174.                  b != p1[8] || b != p1[9])
  175.                   )
  176.               ++p1, --left1;
  177.             if ( left1 < min_repeat_run )
  178.               break;        /* no repeated data left */
  179.             write_data_run(p, (int)(p1 - p + 1), prn_stream,
  180.                        invert);
  181.             /* Detect a maximal run of repeated data. */
  182.             p = ++p1 + (min_repeat_run - 1);
  183.             left = --left1 - (min_repeat_run - 1);
  184.             while ( left > 0 && *p == b )
  185.               ++p, --left;
  186.             for ( count = p - p1; count > 0;
  187.                   count -= count_left
  188.                 )
  189.               {    count_left = min(count, max_repeat_run);
  190.                 if ( count_left > max_repeat_run_code )
  191.                   fputc(xdigit_code + (count_left >> 4),
  192.                     prn_stream),
  193.                   fputc(repeat_run_code + (count_left & 0xf),
  194.                     prn_stream);
  195.                 else
  196.                   putc(repeat_run_code + count_left,
  197.                        prn_stream);
  198.               }
  199.           }
  200.         /* Write the remaining data, if any. */
  201.         write_data_run(p, left, prn_stream, invert);
  202.       }
  203.  
  204.     /* Clean up and return. */
  205.     fputs("\r\n", prn_stream);
  206.     gs_free((char *)line, line_size, 1, "psmono_print_page");
  207.     return 0;
  208. }
  209.  
  210. /* Write a run of data on the file. */
  211. private void
  212. write_data_run(const byte *data, int count, FILE *f, byte invert)
  213. {    register const byte *p = data;
  214.     register const char _ds *hex_digits = "0123456789abcdef";
  215.     int left = count;
  216.     char line[sizeof(count) * 2 + max_data_per_line * 2 + 3];
  217.     char *q = line;
  218.  
  219.     /* Write the count. */
  220.  
  221.     if ( !count )
  222.       return;
  223.     { int shift = sizeof(count) * 8;
  224.       while ( (shift -= 4) > 0 && (count >> shift) == 0 ) ;
  225.       for ( ; shift > 0; shift -= 4 )
  226.         *q++ = xdigit_code + ((count >> shift) & 0xf);
  227.       *q++ = data_run_code + (count & 0xf);
  228.     }
  229.  
  230.     /* Write the data. */
  231.  
  232.     while ( left > 0 )
  233.       {    register int wcount = min(left, max_data_per_line);
  234.         left -= wcount;
  235.         for ( ; wcount > 0; ++p, --wcount )
  236.           {    byte b = *p ^ invert;
  237.             *q++ = hex_digits[b >> 4];
  238.             *q++ = hex_digits[b & 0xf];
  239.           }
  240.         *q++ = '\r';
  241.         *q++ = '\n';
  242.         fwrite(line, 1, q - line, f);
  243.         q = line;
  244.       }
  245.  
  246. }
  247.